#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
字段管理示例

这个脚本展示了如何在实际场景中使用字段操作功能，包括：
1. 批量创建不同类型的字段
2. 管理字段属性和描述
3. 字段的批量更新和清理
"""

import sys
import os
import json
import uuid
from typing import List, Dict, Any
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

from feishu_bitable_client import FeishuBitableClient
from config import Config

class FieldManager:
    """字段管理器"""
    
    def __init__(self, client: FeishuBitableClient, app_token: str, table_id: str):
        self.client = client
        self.app_token = app_token
        self.table_id = table_id
        self.created_fields = []  # 记录创建的字段，便于清理
    
    def create_sample_fields(self) -> List[Dict[str, Any]]:
        """创建示例字段"""
        print("📝 创建示例字段...")
        
        # 定义要创建的字段
        fields_to_create = [
            {
                'name': '商品名称',
                'type': 1,  # 文本
                'description': {'text': '商品的名称'},
                'ui_type': 'Text'
            },
            {
                'name': '价格',
                'type': 2,  # 数字
                'description': {'text': '商品价格（元）'},
                'ui_type': 'Number',
                'property': {
                    'precision': 2,  # 保留2位小数
                    'symbol': '¥'    # 货币符号
                }
            },
            {
                'name': '状态',
                'type': 3,  # 单选
                'description': {'text': '商品状态'},
                'property': {
                    'options': [
                        {'name': '在售', 'color': 0},
                        {'name': '缺货', 'color': 1},
                        {'name': '下架', 'color': 2}
                    ]
                }
            },
            {
                'name': '标签',
                'type': 4,  # 多选
                'description': {'text': '商品标签'},
                'property': {
                    'options': [
                        {'name': '热销', 'color': 0},
                        {'name': '新品', 'color': 1},
                        {'name': '促销', 'color': 2},
                        {'name': '限量', 'color': 3}
                    ]
                }
            },
            {
                'name': '上架日期',
                'type': 5,  # 日期
                'description': {'text': '商品上架日期'},
                'property': {
                    'date_format': 'yyyy/MM/dd',
                    'auto_fill': False
                }
            }
        ]
        
        created_fields = []
        
        for field_def in fields_to_create:
            try:
                print(f"   创建字段: {field_def['name']}...")
                
                result = self.client.create_field(
                    app_token=self.app_token,
                    table_id=self.table_id,
                    field_name=field_def['name'],
                    field_type=field_def['type'],
                    property=field_def.get('property'),
                    description=field_def.get('description'),
                    ui_type=field_def.get('ui_type'),
                    client_token=str(uuid.uuid4())
                )
                
                if result.get('code') == 0:
                    field_info = result.get('data', {}).get('field', {})
                    created_fields.append(field_info)
                    self.created_fields.append(field_info.get('field_id'))
                    print(f"   ✅ 成功创建: {field_info.get('field_name')} (ID: {field_info.get('field_id')})")
                else:
                    print(f"   ❌ 创建失败: {result.get('msg')}")
                    
            except Exception as e:
                print(f"   ❌ 创建字段 {field_def['name']} 时发生错误: {e}")
        
        print(f"\n✅ 成功创建 {len(created_fields)} 个字段")
        return created_fields
    
    def list_all_fields(self) -> List[Dict[str, Any]]:
        """列出所有字段"""
        print("📋 列出所有字段...")
        
        try:
            result = self.client.list_fields(
                app_token=self.app_token,
                table_id=self.table_id,
                page_size=50
            )
            
            if result.get('code') == 0:
                fields = result.get('data', {}).get('items', [])
                print(f"✅ 找到 {len(fields)} 个字段:")
                
                for field in fields:
                    field_type_name = self._get_field_type_name(field.get('type'))
                    is_primary = '(主字段)' if field.get('is_primary') else ''
                    print(f"   - {field.get('field_name')} {is_primary}")
                    print(f"     ID: {field.get('field_id')}, 类型: {field_type_name}, UI类型: {field.get('ui_type')}")
                
                return fields
            else:
                print(f"❌ 列出字段失败: {result.get('msg')}")
                return []
                
        except Exception as e:
            print(f"❌ 列出字段时发生错误: {e}")
            return []
    
    def update_field_descriptions(self, fields: List[Dict[str, Any]]) -> None:
        """批量更新字段描述"""
        print("\n✏️ 更新字段描述...")
        
        # 为我们创建的字段添加更详细的描述
        description_updates = {
            '商品名称': {'text': '商品的完整名称，用于标识和展示'},
            '价格': {'text': '商品的销售价格，单位为人民币元，支持小数'},
            '状态': {'text': '商品当前的销售状态：在售/缺货/下架'},
            '标签': {'text': '商品的分类标签，可多选，用于筛选和推荐'},
            '上架日期': {'text': '商品首次上架的日期，用于统计和排序'}
        }
        
        for field in fields:
            field_name = field.get('field_name')
            field_id = field.get('field_id')
            
            if field_name in description_updates:
                try:
                    print(f"   更新字段描述: {field_name}...")
                    
                    result = self.client.update_field(
                        app_token=self.app_token,
                        table_id=self.table_id,
                        field_id=field_id,
                        field_name=field_name,
                        field_type=field.get('type'),
                        description=description_updates[field_name],
                        ui_type=field.get('ui_type')
                    )
                    
                    if result.get('code') == 0:
                        print(f"   ✅ 成功更新: {field_name}")
                    else:
                        print(f"   ❌ 更新失败: {result.get('msg')}")
                        
                except Exception as e:
                    print(f"   ❌ 更新字段 {field_name} 时发生错误: {e}")
    
    def cleanup_created_fields(self) -> None:
        """清理创建的测试字段"""
        if not self.created_fields:
            print("\n🧹 没有需要清理的字段")
            return
        
        print(f"\n🧹 清理 {len(self.created_fields)} 个测试字段...")
        
        for field_id in self.created_fields:
            try:
                result = self.client.delete_field(
                    app_token=self.app_token,
                    table_id=self.table_id,
                    field_id=field_id
                )
                
                if result.get('code') == 0:
                    print(f"   ✅ 成功删除字段: {field_id}")
                else:
                    print(f"   ❌ 删除字段失败: {result.get('msg')}")
                    
            except Exception as e:
                print(f"   ❌ 删除字段 {field_id} 时发生错误: {e}")
        
        self.created_fields.clear()
        print("✅ 清理完成")
    
    def _get_field_type_name(self, field_type: int) -> str:
        """获取字段类型名称"""
        type_names = {
            1: '文本',
            2: '数字', 
            3: '单选',
            4: '多选',
            5: '日期',
            11: '人员',
            20: '公式',
            # 可以继续添加其他类型
        }
        return type_names.get(field_type, f'未知类型({field_type})')

def main():
    """主函数"""
    print("🚀 字段管理示例")
    print("=" * 50)
    
    # 从配置文件加载应用信息
    config = Config()
    
    # 创建客户端
    client = FeishuBitableClient(
        client_id=config.CLIENT_ID,
        client_secret=config.CLIENT_SECRET
    )
    
    # 确保有有效的访问令牌
    if not client.ensure_valid_token():
        print("❌ 无法获取访问令牌")
        return
    
    print("✅ 成功获取访问令牌")
    print()
    
    # 创建字段管理器
    field_manager = FieldManager(client, config.APP_TOKEN, config.TABLE_ID)
    
    try:
        # 1. 列出现有字段
        print("📋 当前字段状态:")
        existing_fields = field_manager.list_all_fields()
        print()
        
        # 2. 创建示例字段
        created_fields = field_manager.create_sample_fields()
        print()
        
        # 3. 再次列出字段，查看创建结果
        print("📋 创建后的字段状态:")
        all_fields = field_manager.list_all_fields()
        print()
        
        # 4. 更新字段描述
        field_manager.update_field_descriptions(created_fields)
        print()
        
        # 询问是否清理测试字段
        cleanup = input("是否清理创建的测试字段？(y/N): ").lower().strip()
        if cleanup in ['y', 'yes', '是']:
            field_manager.cleanup_created_fields()
        else:
            print("\n💡 测试字段已保留，可以手动删除或稍后清理")
            print(f"   创建的字段ID: {field_manager.created_fields}")
        
        print("\n🎉 字段管理示例完成！")
        
    except KeyboardInterrupt:
        print("\n\n⚠️ 用户中断操作")
        cleanup = input("是否清理已创建的测试字段？(y/N): ").lower().strip()
        if cleanup in ['y', 'yes', '是']:
            field_manager.cleanup_created_fields()
    
    except Exception as e:
        print(f"\n❌ 执行过程中发生错误: {e}")
        import traceback
        traceback.print_exc()
        
        # 尝试清理
        try:
            field_manager.cleanup_created_fields()
        except:
            pass

if __name__ == "__main__":
    main()